In `@backends/advanced/src/advanced_omi_backend/app_factory.py`:
- Around line 111-119: The import and Beanie model list incorrectly reference a
non-existent Annotation class; remove Annotation from the import statement that
currently reads "from advanced_omi_backend.models.annotation import Annotation,
TranscriptAnnotation" and also remove Annotation from the document_models list
passed to init_beanie (which currently includes User, Conversation,
AudioChunkDocument, WaveformData, Annotation, TranscriptAnnotation), leaving
only the actual model classes (e.g., TranscriptAnnotation, AudioChunkDocument,
WaveformData, Conversation, User) so the app no longer raises ImportError on
startup.

In `@backends/advanced/src/advanced_omi_backend/cron.py`:
- Around line 34-38: Initialize last_suggestion_run and last_training_run as
timezone-aware datetimes (e.g., set via
datetime.min.replace(tzinfo=timezone.utc)) or None and add a brief comment if
the immediate first-run behavior for surface_error_suggestions and
finetune_hallucination_model is intentional; replace datetime.utcnow() with
datetime.now(timezone.utc) throughout to use timezone-aware "now" and ensure any
subtraction or comparisons between now and last_* use matching tz-aware values
to avoid TypeError.

In `@backends/advanced/src/advanced_omi_backend/models/annotation.py`:
- Line 20: TranscriptAnnotation currently overrides id as a plain str (id: str =
Field(default_factory=lambda: str(uuid.uuid4()))) which diverges from Beanie
conventions; update TranscriptAnnotation.id to use Beanie's PydanticObjectId
type and default to an ObjectId (import PydanticObjectId from beanie and change
the field declaration on the TranscriptAnnotation class), or alternatively
remove the custom id so Beanie provides the default _id, and if you need a UUID
string keep it as a separate field like transcript_uuid; update imports to
include PydanticObjectId and adjust any code that assumes id is a str to use its
string representation when needed.

In `@backends/advanced/src/advanced_omi_backend/routers/api_router.py`:
- Line 27: Remove the duplicate import and double-mounted router: delete the
second import of annotation_router so it is imported only once, and remove one
of the two include_router(...) calls that registers annotation_router (either
the one that uses the prefix inside annotation_routes.py or the explicit
include_router(annotation_router, prefix="/annotations") call); prefer keeping
the explicit include_router(annotation_router, prefix="/annotations") mounting
and ensure annotation_routes.py’s internal prefix is not also applied to avoid
registering endpoints twice.

In `@backends/advanced/src/advanced_omi_backend/routers/modules/__init__.py`:
- Line 36: Remove the duplicate import and duplicate __all__ entry for
annotation_router: keep the original import of annotation_router (the one
already present) and delete the second "from .annotation_routes import router as
annotation_router" and the repeated "annotation_router" string in the __all__
list so annotation_router is only imported and exported once.

In
`@backends/advanced/src/advanced_omi_backend/routers/modules/annotation_routes.py`:
- Around line 94-115: The GET handler get_annotations currently only filters
TranscriptAnnotation by user_id but doesn't verify that the conversation itself
belongs to current_user; update get_annotations to first load the Conversation
(or equivalent model) by conversation_id and check its owner against
current_user.id (or raise HTTPException 404/403), mirroring the POST endpoint's
ownership check, and only then query TranscriptAnnotation.find(...) for
annotations to build AnnotationResponse objects; reference get_annotations,
current_active_user, TranscriptAnnotation, AnnotationResponse and the
Conversation model/name used in the codebase when implementing the check.
- Around line 56-82: The annotation is being persisted before validating the
conversation's active transcript and segment index, which can leave orphaned
annotations; move the validation and transcript update logic to run before
calling new_annotation.insert(): first check conversation.active_transcript
exists and that 0 <= annotation.segment_index < len(version.segments), update
version.segments[annotation.segment_index].text and replace the entry in
conversation.transcript_versions and call await conversation.save(), then call
await new_annotation.insert(), and finally call enqueue_memory_processing(...).
Keep the existing symbols (new_annotation.insert(),
conversation.active_transcript, annotation.segment_index,
conversation.transcript_versions, conversation.save(),
enqueue_memory_processing) and raise the same HTTPExceptions on validation
failure.

In `@backends/advanced/src/advanced_omi_backend/workers/annotation_jobs.py`:
- Around line 20-24: Replace the naive UTC call with an aware UTC datetime:
compute "since" using datetime.now(timezone.utc) minus timedelta to produce an
aware datetime (matching TranscriptAnnotation timestamps) before passing it into
Conversation.find; update the import if needed (ensure timezone is imported) and
reference the existing "since" variable in annotation_jobs.py where
Conversation.find({"created_at": {"$gte": since}}) is invoked so the query
compares two timezone-aware datetimes.

In `@backends/advanced/src/advanced_omi_backend/workers/base_audio_worker.py`:
- Around line 126-138: The shutdown can hang because awaiting consumer_task has
no timeout and stop_wait_task is never cancelled; modify the shutdown sequence
in the method that calls self.consumer.stop() so you await consumer_task with a
bounded timeout (e.g., use asyncio.wait_for on consumer_task) and handle
asyncio.TimeoutError by cancelling consumer_task and logging; also ensure
stop_wait_task is cancelled if consumer_task completes first (call
stop_wait_task.cancel() and await it safely), and keep existing exception
handling for CancelledError and other exceptions when awaiting consumer_task and
stop_wait_task; reference self.consumer.stop(), consumer_task,
start_consuming(), and stop_wait_task when applying these changes.

In `@backends/advanced/src/advanced_omi_backend/workers/memory_jobs.py`:
- Around line 285-300: The try/except around enqueuing the summary job in
enqueue_memory_processing currently logs and re-raises the error which causes
the caller to never receive the already-enqueued primary memory job (job).
Change the except block so it logs the full exception (include e) and continues
without raising (so the function can return job); if you must re-raise in other
contexts, use bare "raise" to preserve traceback; update references:
enqueue_memory_processing, summary_job_id, generate_title_summary_job, job, and
logger.
- Around line 138-178: The NameError occurs because processing_time is only set
inside the if conversation_model: block; compute processing_time before
fetching/refetching the Conversation so it's always defined (e.g., right after
the success and created_memory_ids check and before calling
Conversation.find_one). Keep the existing usage of processing_time in
conversation_model.add_memory_version and logger.info unchanged; this ensures
processing_time is available whether conversation_model is None or not while
preserving the version creation logic in add_memory_version, and reference the
existing symbols conversation_model, Conversation.find_one, start_time,
processing_time, created_memory_ids, memory_service, and logger.info when making
the change.

In `@backends/advanced/tests/unit/workers/test_audio_stream_workers.py`:
- Around line 240-253: The test is calling instance.run() instead of testing the
classmethod start(); update
TestParakeetStreamWorker.test_start_method_runs_worker to invoke
ParakeetStreamWorker.start() (or await ParakeetStreamWorker.start() if async)
rather than creating an instance and awaiting run(), keep the existing patches
for ParakeetStreamWorker.run (AsyncMock) and asyncio.run so the classmethod
triggers the patched run and then assert mock_run.assert_called_once(); this
replaces the worker_instance = ParakeetStreamWorker(); await
worker_instance.run() sequence with a call to the start() entrypoint.
- Around line 175-188: The test test_start_method_runs_worker is misnamed and
doesn't exercise DeepgramStreamWorker.start; change it to call
DeepgramStreamWorker.start() synchronously (instead of awaiting
worker_instance.run()) and assert that asyncio.run was invoked with the worker's
run() coroutine; keep the AsyncMock patch on DeepgramStreamWorker.run to prevent
real execution and verify mock run was scheduled via asyncio.run, and remove the
unused direct await of run().

In `@services.py`:
- Line 274: The string passed to console.print in the failure case uses an
unnecessary f-string prefix; remove the leading f from the literal in the
console.print call so it becomes a normal string (i.e., change the console.print
call that currently reads console.print(f"[red]❌ Command failed[/red]") to use a
plain string), keeping the same message and formatting; this fixes the Ruff F541
warning in the function containing that console.print.
- Around line 81-95: _get_service_path currently assumes service_name exists in
SERVICES and will raise KeyError; add an explicit membership check for
service_name in SERVICES at the start of _get_service_path, and if missing call
console.print with a clear error (e.g., "Service not found: {service_name}") and
return None so callers like run_compose_command get a clean failure instead of
an exception; keep the existing checks for service_path.exists() and
compose_file.exists() (service_path and compose_file symbols) unchanged.
- Around line 466-470: When args.all is set we currently build
services_to_process by filtering SERVICES via check_service_configured, which
causes stop --all to skip services missing a .env; change the logic so that for
the stop action we do not filter by check_service_configured: detect the
command/action (e.g., stop vs start/restart) and when action == "stop" populate
services_to_process = list(SERVICES.keys()) (or remove the
check_service_configured filter), while keeping the existing check for
start/restart so start still requires a configured service; update references to
services_to_process and args.all accordingly.

In `@wizard.py`:
- Line 551: Remove the unnecessary f-string prefixes on the console.print calls
that don't use any interpolations; specifically update the console.print
invocation(s) in wizard.py (e.g., the call that prints "🎊 [bold green]Setup
Complete![/bold green]" and the other similar console.print at line ~560) to use
plain string literals instead of f-strings (remove the leading 'f' from those
string literals).